/*
背景
以下是几个标准的表达式：
5 * 2 + -3
5 * (2 + -3)
5 + ((-4 * -5) + (((5 + (6 - 2)) * 7 + ((4 + 2) * (3 - 1))))
	与之等价的波兰表达式为
	+ *5 2 -3
	* 5 + 2 -3
	+ 5 + *-4 - 5 + *+5 - 6 2 7 * +4 2 - 3 1
	在普通的表达式中，符号是位于运算对象之间的，而在波兰表达式中，运算符号位于参与运算的对象之前。
	波兰式在计算中的价值在于它不需要使用括号，之所以如此是由于波兰式的操作符的先后顺序是明确的。
	如果我们用 P 表示波兰表达式，用 O 表示操作符，用 D 表示数字，则可以将波兰表达式定义为 P = O P P 或 P = D。


	任务
	编写程序计算波兰表达式的值。


	输入
	输入第一行是一个整数，表示输入文件中共有几个波兰式。
	以后每行一个表达式。每个表达式长度不超过 80 个字符，且每个表达式仅包含数字(取值范围是[-10000, 10000]) 和二元操作符 + 、 - 和 * 。任何表达式或子表达式的值都在[-1000000, 1000000] 范围内。每个数字与操作符之间，至少有一个空格作为间隔。(负号是整数值的一部分，不是操作符，并且和整数值之间没有空格。)
	输出
	对每个表达式输出其值。
*/



#ifdef _MSC_VER
#define _CRT_SECURE_NO_WARNINGS
#endif
#if defined(_WIN32) && !defined(__cplusplus)
#define inline __inline
#endif

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX_STACK_SIZE 100
#define MAX_ITEM_LENGTH 8

#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
typedef int Status;		/* Status是函数的类型,其值是函数结果状态代码，如OK等 */
typedef int BOOL;	/* Boolean是布尔类型,其值是TRUE或FALSE */

typedef enum
{
	ItemTypeOperand = 1,
	ItemTypeOperator = 2,
}ItemType;

typedef char* SElemType;

#ifndef INT_MIN
#define INT_MIN		0x80000000 // minimum (signed) int value
#endif 

#ifndef INT_MAX
#define INT_MAX		0x7FFFFFFF    // maximum (signed) int value
#endif 

// rear 指向下一个空位
typedef struct
{
	int stacksize;
	int top, base;
	SElemType data[MAX_STACK_SIZE];
}SqStack;

Status InitStack(SqStack *S)
{ /* 构造一个空栈S */
	memset(S->data, 0, sizeof(SElemType) * MAX_STACK_SIZE);
	S->top = S->base = 0;
	S->stacksize = MAX_STACK_SIZE;
	return OK;
}

BOOL StackEmpty(SqStack S)
{ /* 若栈S为空栈，则返回TRUE，否则返回FALSE */
	return S.top == S.base;
}

Status StackPush(SqStack *S, SElemType e)
{ /* 插入元素e为新的栈顶元素 */
	if (S->top - S->base >= S->stacksize) return ERROR;
	S->data[S->top] = (char *)malloc(strlen(e) + 1);
	strcpy(S->data[S->top], e);
	++S->top;
	S->data[S->top] = NULL;
	return OK;
}

Status Pop(SqStack *S, SElemType e)
{ /* 若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR */
	if (StackEmpty(*S)) return ERROR;
	--S->top;
	strcpy(e, S->data[S->top]);
	free(S->data[S->top]);
	S->data[S->top] = NULL;
	return OK;
}

Status StackClear(SqStack *S)
{ /* 把S置为空栈 */
	S->top = 0;
	S->base = 0;
	S->stacksize = MAX_STACK_SIZE;
	return OK;
}

ItemType GetItemType(const char *item)
{
	switch (item[0])
	{
		case '+':
		case '*':
		case '/':
			return ItemTypeOperator;
		case '-':
		{
			if (item[1] == 0) return ItemTypeOperator;
			break;
		}
	}
	return ItemTypeOperand;
}

BOOL GetItem(char *item)
{
	BOOL finish = FALSE;
	int i = 0;
	for (;; i++)
	{
		char temp = getchar();
		if (temp == ' ') break;
		else if (temp == '\n')
		{
			finish = TRUE;
			break;
		}
		item[i] = temp;
	}
	item[i] = 0;
	return finish;
}

SElemType GetStackTop(SqStack S)
{
	return S.data[S.top - 1];
}

int Calc(int lOperand, int rOperand, char curOperator)
{
	switch (curOperator)
	{
		case '+': return lOperand + rOperand;
		case '-': return lOperand - rOperand;
		case '*': return lOperand * rOperand;
	}
	return INT_MIN;
}

void CalcAll(SqStack *stack, const char *rItem)
{
	char temp[MAX_ITEM_LENGTH];
	strcpy(temp, rItem);
	while (!StackEmpty(*stack))
	{
		if (GetItemType(GetStackTop(*stack)) != ItemTypeOperand)
		{
			StackPush(stack, temp);
			return;
		}
		else
		{
			char lItem[MAX_ITEM_LENGTH] = {0};
			char curOperator[MAX_ITEM_LENGTH] = {0};
			Pop(stack, lItem);
			Pop(stack, curOperator);
			int rOperand = atoi(temp);
			int lOperand = atoi(lItem);
			int result = Calc(lOperand, rOperand, curOperator[0]);
			sprintf(temp, "%d", result);
		}
	}
	StackPush(stack, temp);
}

int main()
{
	int n;
	scanf("%d", &n);
	getchar();

	SqStack stack;
	InitStack(&stack);

	for (int i = 0; i < n; i++)
	{
		while (1)
		{
			char temp[MAX_ITEM_LENGTH] = {0};
			BOOL finish = GetItem(temp);
			if (GetItemType(temp) == ItemTypeOperand)CalcAll(&stack, temp);
			else StackPush(&stack, temp);
			if (finish) break;
		}

		char rItem[MAX_ITEM_LENGTH] = {0};
		Pop(&stack, rItem);
		printf("%s\n", rItem);
		StackClear(&stack);
	}

	return 0;
}
